package com.atguigu.redis7.set;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.atguigu.redis7.course.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@Component
public class Test {

    @Autowired
    private RedisTemplate redisTemplate;

    //查询当前用户是否关注该用户
    public Result isFollow(Long userId) {
        Long userid = 2L; //模拟获取当前用户id

        //去数据库查就行了

        return null;
    }

    //去关注用户
    public Result follow(Long userId, boolean flag) {

        Long userid = 2L; //模拟获取当前用户id

        //关注
        if (flag) {
            //数据库操作

            //加入进redis
            //key  follow:当前用户id  value被关注用户的id
            redisTemplate.opsForSet().add("key", "followdId");
        }
        //取关
        else {
            //数据库操作

            //删除redis中的数据
            //key  follow:当前用户id  value被关注用户的id
            redisTemplate.opsForSet().remove("key", "followdId");

        }
        return Result.ok();
    }


    //求交集，共同好友
    public Result followCommons(Long id) {
        Long userId = 2L; //模拟
        String FOLLOW_USER_ID = "follow:";
        String key1 = FOLLOW_USER_ID + userId;  //当前登录用户的关注列表集合
        String key2 = FOLLOW_USER_ID + id;  //点击查看的用户的关注列表集合
        //求交集
        Set<String> intersect = redisTemplate.opsForSet().intersect(key1, key2);
        if (intersect == null || intersect.isEmpty()) {
            //无交集
            return Result.ok(Collections.emptyList());
        }
        //解析id集合
        List<Long> ids = intersect.stream().map(Long::valueOf).collect(Collectors.toList());

        //这里拿到的只是id，还有去数据库中查询数据

        return Result.ok();
    }

//    public Result saveBlog(Blog blog) {
//        // 获取登录用户
//        UserDTO user = UserHolder.getUser();
//        blog.setUserId(user.getId());
//        // 保存探店博文
//        boolean isSuccess = save(blog);
//        if (!isSuccess){
//            return Result.fail("发布失败，请检查重试");
//        }
//        // 查询博文作者的所有粉丝
//        List<Follow> follows = followService.query().eq("follow_user_id", user.getId()).list();
//        for (Follow follow : follows) {
//            // 获取粉丝id
//            Long userId = follow.getUserId();
//            // 推送笔记id给所有粉丝
//            String key = "feed:" + userId;
//            stringRedisTemplate.opsForZSet().add(key, blog.getId().toString(), System.currentTimeMillis());
//        }
//        // 返回id
//        return Result.ok(blog.getId());
//    }
    /**
     * 滚动查询，展示博主推送的笔记， 新发布的滚动查询查不到，但是往上滚，前端做了处理，就是刷新重新查询，开始位置在当前最新位置
     * @param max
     * @param offset
     * @return
     */
//    public Result queryBlogOfFollow(Long max, Integer offset) {
//        //获取当前用户
//        Long userId = UserHolder.getUser().getId();
//        //查询收件箱 ZREVRANGEBYSCORE key Max Min LIMIT offset count    limit是小于等于的意思，小于等于查询的最后时间戳
//        String key = "feed:" + userId;
//        Set<ZSetOperations.TypedTuple<String>> typedTuples = stringRedisTemplate.opsForZSet()
//                .reverseRangeByScoreWithScores(key, 0, max, offset, 2);
//        //非空判断
//        if (typedTuples == null || typedTuples.isEmpty()){
//            return Result.ok();
//        }
//        //解析数据： blogId，minTime（时间戳）， offset
//        ArrayList<Object> ids = new ArrayList<>(typedTuples.size());
//        long minTime = 0;  //这个minTime是上次查询的最小时间戳，作为当次查询的最大时间戳来开始查
//        int os = 1;
//        for (ZSetOperations.TypedTuple<String> typedTuple : typedTuples) {
//            //获取博客id转换为Long型并存入ids数组中
//            ids.add(Long.valueOf(typedTuple.getValue()));
//            //获取分数      判读得到最后一次的时间戳，以及偏移量
//            long time = typedTuple.getScore().longValue();
//            if (time == minTime){
//                os++;
//            }else {
//                minTime = time;
//                os = 1;
//            }
//        }
//
//        //根据id查询blog，先把前面保存id的ids数组转为字符串
//        String idStr = StrUtil.join(",", ids); //由于用mp提供的listByIds是用in方法查，不能保证顺序
//        List<Blog> blogs = query().in("id", ids).last("order by field(id," + idStr + ")").list();
//        for (Blog blog : blogs) {
//            //查询blog有关用户信息
//            queryBlogUser(blog);
//            //查询blog是否已被点赞
//            isBlogLinked(blog);
//        }
//
//        //封装并返回
//        ScrollResult r = new ScrollResult();
//        r.setList(blogs);
//        r.setOffset(os);
//        r.setMinTime(minTime);
//        return Result.ok(r);
//    }

}
